#include "soapH.h"
#include "messenger.nsmap"
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <signal.h>
#include "pthread.h"
#define BACKLOG (100)

struct ListaUsuarios usuariosRegistrados;
struct ListaUsuarios usuariosOnline;

int guardarListaUsuarios();
int leer_bin();
void salir(int senal);
void mostrarUsuario(struct Usuario user);
void mostrarPunteroUsuario(struct Usuario *user);
int comprobarNick(char * nick);
void leer_amigo();
int valor;

int main(int argc, char **argv) {
	signal(SIGINT, salir);
	printf("BIENVENIDO\n");

	struct soap soap;
	valor = 0;
	soap_init(&soap);

	if (argc < 2) {
		printf("Usage: %s <port>\n", argv[0]);
		exit(-1);
		soap_serve(&soap);
		soap_destroy(&soap);
		soap_end(&soap);
	} else {
		soap.send_timeout = 60;
		soap.recv_timeout = 60;
		soap.accept_timeout = 3600;
		soap.max_keep_alive = 100;
		void *process_request(void*);
		struct soap *tsoap;
		pthread_t tid;
		int port = 8080;
		printf("el puerto es  %d", port);
		SOAP_SOCKET m, s;

		m = soap_bind(&soap, NULL, port, BACKLOG);
		if (!soap_valid_socket(m)) {
			soap_print_fault(&soap, stderr);
			exit(1);

		}
		int *nmax = 0;
		//struct Usuario *usuario = (struct Usuario *) malloc(sizeof(struct Usuario));
		fprintf(stderr, "Socket connection successful %d\n", m);

		//leer_bin();

		printf("DESPUES DE CARGAR @ usuariosRegistrados.iterador ,%d\n",
				usuariosRegistrados.iterador);
		int i;
		for (i = 0; i <= usuariosRegistrados.iterador; i++) {
			printf("contenido de la pos %d, es %s\n", i,
					usuariosRegistrados.listaUsuarios[i].nickName);
		}
		for (;;) {
			s = soap_accept(&soap);
			if (!soap_valid_socket(s)) {
				if (soap.errnum) {
					soap_print_fault(&soap, stderr);
					exit(1);
				}
				fprintf(stderr, "server timed out\n");
				break;
			}
			soap_serve(&soap);
			soap_end(&soap);

			tsoap = soap_copy(&soap);
			if (!tsoap)
				break;
			pthread_create(&tid, NULL, (void*(*)(void*)) process_request,
					(void*) tsoap);
		}
	}
	soap_done(&soap);
	return 0;

}
void *process_request(void *soap) {

	pthread_detach(pthread_self());
	soap_serve((struct soap*) soap);
	soap_destroy((struct soap* )soap);
	soap_end((struct soap*) soap);
	soap_done((struct soap*) soap);
	free(soap);

	return NULL;
}

int ns__bajaUsr(struct soap *soap,char* nick, int* res, int* id) {
	int cons=comprobarNick(nick);
	if(cons!=-1)
		usuariosRegistrados.listaUsuarios[cons].dadoBaja=1;

	return SOAP_OK;
}

int ns__altaUsr(struct soap *soap, struct Usuario user, int *res, int *id) {
	int idUsuario = comprobarNick(user.nickName);
	printf("\ncomprobarNick(user->nickName) == %d\n", idUsuario);
	if (idUsuario == -1) { //no existe usuario
		*id = creaUsuario(user, id);
		printf("res=%d\n", *id);
	} else {
		*res = -1;
		*id = -1;
	}
	return SOAP_OK;

}

int ns__getAllSOAPServices2(struct soap *soap, struct ListaFriendShip *p) {

	int i;
	for (i = 0; i < usuariosOnline.iterador; i++) {

		strcpy(p->frienShip[i].user, usuariosOnline.listaUsuarios[i].nickName);
		p->frienShip[i].sender = comprobarNick(p->frienShip[i].user);
		printf(" existe y su ID es %d y nombre %s\n", p->frienShip[i].sender,
				p->frienShip[i].user);
		p->iterador = i;
	}

	p = malloc(sizeof(struct ListaFriendShip));

	return SOAP_OK;

}
int ns__getUsersOnline(struct soap *soap, struct ListaFriendShip listaFriends,
		int *res) {
	int i;
	for (i = 0; i <= usuariosRegistrados.iterador; i++) {
		strcpy(listaFriends.frienShip[i].user,
				usuariosRegistrados.listaUsuarios[i].nickName);

		listaFriends.iterador = i;
	}
	return SOAP_OK;
}
int ns__loggin(struct soap *soap, char *usr, int *id, int *res) {
	*id = comprobarNick(usr);
	printf("he comprobado el nick/n\n");
	if (*id == -1) {
		printf("no existe\n");
		*res = *id;
		//return -1;
	} else {
		printf(" existe y su ID es %d\n", *id);
		*res = *id;
		usuariosOnline.listaUsuarios[usuariosOnline.iterador++] =
				usuariosRegistrados.listaUsuarios[*id];
		//return *id;
	}
	return SOAP_OK;
}

int creaUsuario(struct Usuario user, int *id) {
	int iter = usuariosRegistrados.iterador;
	struct Usuario usrLocal = user;
	if (iter < 50) {
		usuariosRegistrados.listaUsuarios[usuariosRegistrados.iterador++] =
				user;
		usuariosRegistrados.listaUsuarios[usuariosRegistrados.iterador - 1].id =
				usuariosRegistrados.iterador;
		usuariosRegistrados.listaUsuarios[usuariosRegistrados.iterador - 1].lista_de_amigos[0] =
				-1;
		return 1;
	} else
		return -1;

}

int comprobarNick(char nick[20]) {
	printf("\nel NICK a comprobar es%s\n", nick);
	int i;
	for (i = 0; i <= usuariosRegistrados.iterador; i++) {
		//if(usuariosRegistrados.listaUsuarios[i].dadoBaja==0){
		printf("\nel valor lista usuario i = %d \n", i);
		printf("\nel nombre es %s\n",usuariosRegistrados.listaUsuarios[i].nickName);

		if (strcmp(usuariosRegistrados.listaUsuarios[i].nickName, nick) == 0) {
			printf("\nDENTRO DE STRCPY\n");
			return i;
		//}
		}
	}
	return -1;

}

int guardarListaUsuarios() {

	FILE *archivo ,*archivo_manssage, *archivo_amigo;
	struct manssage manssage_local;
	struct manssage *manssage_local_p;
	struct ListaAmigos *listaAmigosIterable;
	struct manssage lista_de_Manssage_local[50];
	int n;
	int un_amigo, pos = 0, pos2 = 0;

	int tam = usuariosRegistrados.iterador;
	int nex = 0;
	archivo = fopen("DatosBanco.dat", "wb");
	//archivo_manssage = fopen("archivo_manssage.dat", "wb");
	archivo_amigo = fopen("archivo_amigo.dat", "wb");
	if (archivo != NULL) {
		int i,j,k;
		for (i = 0; i < tam; i++) {
			struct Usuario *usuario = malloc(sizeof(struct Usuario));
			usuario = &usuariosRegistrados.listaUsuarios[i];
			mostrarPunteroUsuario(usuario);

//			manssage_local_p= malloc(sizeof(struct manssage));
//			manssage_local_p->nomr=usuario->id;
//			for (j = 0; j < usuariosRegistrados.listaUsuarios[usuario->id].cont_manssage;j++){
//
//				strcpy(manssage_local_p->manssage,usuariosRegistrados.listaUsuarios[usuario->id].lista_de_Manssage[j].manssage);
//				fwrite(&manssage_local_p, sizeof(struct manssage), 1,archivo_manssage);
//			}


			for (j = 0; j < usuariosRegistrados.listaUsuarios[usuario->id].cont_lista_amigos;j++){
				printf("\n Dentro lista amigos 1\n");
				listaAmigosIterable= malloc(sizeof(struct ListaAmigos));
				listaAmigosIterable->user=usuario->id;
				printf("\n Dentro lista amigos \n");
				listaAmigosIterable->lista_de_amigos_local[j]=usuariosRegistrados.listaUsuarios[usuario->id].lista_de_amigos[j];
				fwrite(&listaAmigosIterable, sizeof(struct ListaAmigos), 1,archivo_amigo);
				}

			fwrite(usuario, sizeof(struct Usuario), 1, archivo);
		}

		fclose(archivo);
		//fclose(archivo_amigo);
		fclose(archivo_manssage);
	}
	return -1;

	return 1;
}
int guardarListaMensajeUsuarios() {
	FILE *archivo;
	int tam = usuariosRegistrados.iterador;
	int nex = 0;
	archivo = fopen("DatosBanco.dat", "wb");
	if (archivo != NULL) {
		int i;
		for (i = 0; i < tam; i++) {
			struct Usuario *usuario = malloc(sizeof(struct Usuario));
			usuario = &usuariosRegistrados.listaUsuarios[i];
			mostrarPunteroUsuario(usuario);
			usuario->iteradorFriendship =
					usuariosRegistrados.listaUsuarios[i].iteradorFriendship;
			usuario->iteradorFriendship =
					usuariosRegistrados.listaUsuarios[i].iteradorFriendship;
			int j;
			for (j = 0;
					j < usuariosRegistrados.listaUsuarios[i].cont_lista_amigos;
					j++)
				usuario->lista_de_amigos[j] =
						usuariosRegistrados.listaUsuarios[i].lista_de_amigos[j];

			for (j = 0; j < usuariosRegistrados.listaUsuarios[i].cont_manssage;
					j++)
				usuario->lista_de_Manssage[j] =
						usuariosRegistrados.listaUsuarios[i].lista_de_Manssage[j];

			for (j = 0;
					j < usuariosRegistrados.listaUsuarios[i].iteradorFriendship;
					j++)
				usuario->friendRequestList[j] =
						usuariosRegistrados.listaUsuarios[i].friendRequestList[j];

			fwrite(usuario, sizeof(struct Usuario), 1, archivo);
		}
		//fwrite(8,EOF,1,archivo);
		fclose(archivo);
	}
	return -1;

	return 1;
}

//while ( (n=read(fd,&c,sizeof(char))) > 0 )
int leer_bin() {

	FILE *archivo, *archivo_manssage, *archivo_amigo;
	int nex = 0;
	int conta = 0;
	struct Usuario usuarioLocal;
	struct manssage manssage_local;
	struct manssage *manssage_local_p;
	struct ListaAmigos *listaAmigosIterable;
	struct manssage lista_de_Manssage_local[50];

	archivo = fopen("DatosBanco.dat", "rb");
//	archivo_manssage = fopen("archivo_manssage.dat", "rb");
	struct Usuario *usuario;
	struct ListaUsuarios local;
	local.iterador=0;
		int j,i;
	int ultimaId = 0;
	int salir = 0;
	usuarioLocal.edad = 100;
	printf("\n archivo abierto\n");
	usuariosRegistrados.iterador = 0;
	if (archivo != NULL) {

		usuario = malloc(sizeof(struct Usuario));

		printf("despues de malloc\n");

		while (fread(usuario, sizeof(struct Usuario), 1, archivo) == 1|| salir == 0) { //!feof(archivo)
			printf("dentro fread\n");
			usuarioLocal.id = usuario->id;
			if (ultimaId != usuario->id) {
				ultimaId = usuario->id;

				usuarioLocal.edad = usuario->edad;
				usuarioLocal.id = usuario->id;//usuariosRegistrados.iterador;
				printf("antes  strcpy\n");
				strcpy(usuarioLocal.nickName, usuario->nickName);

				usuarioLocal.cont_lista_amigos = usuario->cont_lista_amigos;

				usuarioLocal.cont_manssage = usuario->cont_manssage;
//				mostrarUsuario(usuarioLocal);
				printf("antes  guardar array\n");
				local.listaUsuarios[usuario->id] = usuarioLocal;
				printf("despues guardar en array\n");
				local.iterador++;
				mostrarUsuario(usuarioLocal);
			} else {
				salir = 1;
				break;
			}

		}

	} else{
			return -1;
			printf("\n archivo  NO abierto\n");
		}
	printf("archivo_amigo\n");
	fclose(archivo);
	archivo_amigo = fopen("archivo_amigo.dat", "rb");
	printf("DESPUES archivo_amigo\n");
if (archivo_amigo != NULL ){//archivo_manssage != NULL &&
	int p;
	printf("DESPUES %d\n",local.iterador);
		for (i = 0; i < local.iterador ;i++){
		//leo ahora los
//			for (p = 0; p < local.listaUsuarios[i].cont_manssage ;p++){
//				fread(manssage_local_p, sizeof(struct manssage), 1, archivo_manssage);
//				manssage_local.nomr=manssage_local_p->nomr;
//				strcpy(local.listaUsuarios[manssage_local.nomr].lista_de_Manssage[p].manssage,manssage_local.manssage);
//			}

			listaAmigosIterable = malloc(sizeof(struct ListaAmigos));
			fread(listaAmigosIterable, sizeof(struct ListaAmigos), 1, archivo_amigo);
			for (p = 0; p < local.listaUsuarios[i].cont_lista_amigos ;p++){
				fread(listaAmigosIterable, sizeof(struct ListaAmigos), 1, archivo_amigo);
				local.listaUsuarios[listaAmigosIterable->user].lista_de_amigos[p]=listaAmigosIterable->lista_de_amigos_local[p];
				printf("el usuario es amigo de  %d\n",local.listaUsuarios[listaAmigosIterable->user].lista_de_amigos[p]);
			}
		}
		usuariosRegistrados=local;
				int o;
				for (o = 0; o <= usuariosRegistrados.iterador; o++) {
					if(o==0){strcpy(usuariosRegistrados.listaUsuarios[o].nickName,"chechex");
					usuariosRegistrados.listaUsuarios[o].dadoBaja=1;

					}
					mostrarUsuario(usuariosRegistrados.listaUsuarios[o]);
				}
}else{
	return -1;
	printf("\n archivo MENSAJE NO abierto\n");
}






		fclose(archivo_amigo);
		//fclose(archivo_manssage);
		printf("fclose(archivo)\n");
		return -1;


	return -1;
}

void leer_manssage(){

	FILE  *archivo_manssage;
	struct Usuario usuarioLocal;
	int n ,pos2=0,i;
	struct manssage manssage_local;
	struct manssage *manssage_local_p;
	struct manssage lista_de_Manssage_local[50];
	archivo_manssage = fopen("archivo_manssage.dat", "rb");

					while ((n = fread(manssage_local_p, sizeof(struct manssage), 1,
							archivo_manssage)) > 0) {

						strcpy(manssage_local.manssage,manssage_local_p->manssage);
						strcpy(manssage_local.receive,manssage_local_p->receive);
						strcpy(manssage_local.sender,manssage_local_p->sender);
						lista_de_Manssage_local[pos2] = manssage_local;
					pos2++;
					}

					for (i = 0; i < pos2; i++) {
						usuariosRegistrados.listaUsuarios[0].lista_de_Manssage[i] =lista_de_Manssage_local[i];
						printf("lista_de_amigos_local[i] %s,\n",lista_de_Manssage_local[i].manssage);
					}


//
//void leer_amigo(){
//	struct Usuario usuarioLocal;
//	FILE  *archivo_amigo;
//	int n,un_amigo ,pos=0,i;
//	int lista_de_amigos_local[50];
//	archivo_amigo = fopen("archivo_amigo.dat", "rb");
//
//			while ((n = fread(un_amigo, sizeof(int), 1, archivo_amigo)) > 0) {
//
//					printf("un_amigo %d,\n",un_amigo);
//					lista_de_amigos_local[pos] = un_amigo;
//						pos++;
//				}
//					for (i = 0; i < pos; i++) {
//						usuarioLocal.lista_de_amigos[i] = 1;
//						usuarioLocal.lista_de_amigos[i] = lista_de_amigos_local[i];
//						printf("lista_de_amigos_local[i] %d,\n",lista_de_amigos_local[i]);
//					}
}

void mostrarPunteroUsuario(struct Usuario *user) {
	printf("user.nickName%s\n", user->nickName);
	printf("user.edad%d\n", user->edad);
	printf("user.id%d\n", user->id);
	printf("user.cont_lista_amigos%d\n", user->cont_lista_amigos);
	printf("user.cont_manssage%d\n", user->cont_manssage);
	printf("user.iteradorFriendship %d\n", user->iteradorFriendship);
	int i;
//	for (i = 0; i < user->cont_lista_amigos; i++)
//		printf("user.lista_de_amigos[i]%d\n", user->lista_de_amigos[i]);
//	for (i = 0; i < user->cont_manssage; i++)
//		printf("user.lista_de_Manssage[i].manssage%s\n",
//				user->lista_de_Manssage[i].manssage);
//	for (i = 0; i < user->iteradorFriendship; i++)
//		printf("user.friendRequestList[i].user%s\n",
//				user->friendRequestList[i].user);

}
void mostrarUsuario(struct Usuario user) {

	printf("user.nickName     %s\n", user.nickName);
	printf("user.edad    %d\n", user.edad);
	printf("user.id     %d\n", user.id);
	printf("user.cont_lista_amigos    %d\n", user.cont_lista_amigos);
	printf("user.cont_manssage    %d\n", user.cont_manssage);
	printf("user.iteradorFriendship    %d\n", user.iteradorFriendship);
	int i;
//	for (i = 0; i < user.cont_lista_amigos; i++)
//		printf("user.lista_de_amigos[i]%d\n", user.lista_de_amigos[i]);
//	for (i = 0; i < user.cont_manssage; i++)
//		printf("user.lista_de_Manssage[i].manssage%s\n",
//				user.lista_de_Manssage[i].manssage);
//	for (i = 0; i < user.iteradorFriendship; i++)
//		printf("user.friendRequestList[i].user%s\n",
//				user.friendRequestList[i].user);

}

int ns__aceptar_Rechazar_solicitudes(struct soap *soap, int userId,
		struct ListaFriendShip *val) {
	//
	printf("\nID USUARIO FROM %d \n", userId);

	printf("\nID TO ACEPTAR %d\n",
			usuariosRegistrados.listaUsuarios[userId].friendRequestList[usuariosRegistrados.listaUsuarios[userId].iteradorFriendship].sender);
	int i = 0;
	printf("\ncopiando las estructuras a la q se devolvera al cliente \n");
	val->iterador = 0;
	for (i = 0;
			i < usuariosRegistrados.listaUsuarios[userId].iteradorFriendship;
			i++) {
		printf("\nsolicitud %d,%s\n",
				usuariosRegistrados.listaUsuarios[userId].friendRequestList[i].sender,
				usuariosRegistrados.listaUsuarios[userId].friendRequestList[i].user);

		strcpy(val->frienShip[i].user,
				usuariosRegistrados.listaUsuarios[userId].friendRequestList[i].user);
		printf("\n val->frienShip[i].user=,%s\n", val->frienShip[i].user);
		val->frienShip[i].sender = comprobarNick(val->frienShip[i].user);
		//usuariosRegistrados.listaUsuarios[userId].friendRequestList[i].sender;
		printf("\n val->frienShip[i].sender %d\n", val->frienShip[i].sender);
		val->iterador++;
	}

	printf("\nfuera del for\n");
	val = malloc(sizeof(struct ListaFriendShip));
	return SOAP_OK;
}

int ns__enviar_solicitudes(struct soap *soap, int userToBeFriend,
		int userWantToBeFriend, int* res) {
	printf("\nuserWantToBeFriend %d\n", userWantToBeFriend);
	printf("\n userToBeFriend %d\n", userToBeFriend);
	printf(
			"\n usuariosRegistrados.listaUsuarios[userToBeFriend].iteradorFriendship] %d\n",
			usuariosRegistrados.listaUsuarios[userToBeFriend].iteradorFriendship);
	strcpy(
			usuariosRegistrados.listaUsuarios[userToBeFriend].friendRequestList[usuariosRegistrados.listaUsuarios[userToBeFriend].iteradorFriendship].user,
			usuariosRegistrados.listaUsuarios[userWantToBeFriend].nickName);

	printf("\nUSUARIO  %s  \n",
			usuariosRegistrados.listaUsuarios[userToBeFriend].friendRequestList[usuariosRegistrados.listaUsuarios[userToBeFriend].iteradorFriendship].user);

	usuariosRegistrados.listaUsuarios[userToBeFriend].friendRequestList[usuariosRegistrados.listaUsuarios[userToBeFriend].iteradorFriendship].sender =
			userWantToBeFriend;
	usuariosRegistrados.listaUsuarios[userToBeFriend].iteradorFriendship++;
	return SOAP_OK;
}

int ns__aceptar_RechazarFriend(struct soap *soap, int respuestaUser,
		int userAcepter, int userSoliciter, int* res) {
	printf("\nRespuesta User = %d\n", respuestaUser);
	if (respuestaUser == 1) {
		printf("\nUSUARIO ACEPTADO\n");
		printf("\nid de id_Receive == %d\n", userAcepter);
		printf("\nid de id_Sender == %d\n", userSoliciter);

		//acepto en uno y otro
		usuariosRegistrados.listaUsuarios[userAcepter].lista_de_amigos[usuariosRegistrados.listaUsuarios[userAcepter].cont_lista_amigos] =
				userSoliciter;
		usuariosRegistrados.listaUsuarios[userSoliciter].lista_de_amigos[usuariosRegistrados.listaUsuarios[userSoliciter].cont_lista_amigos] =
				userAcepter;
		usuariosRegistrados.listaUsuarios[userAcepter].cont_lista_amigos++;
		usuariosRegistrados.listaUsuarios[userSoliciter].cont_lista_amigos++;

		*res = 1;
	} else {
		printf("\nUSUARIO RECHAZADO\n");
		usuariosRegistrados.listaUsuarios[userAcepter].friendRequestList[usuariosRegistrados.listaUsuarios[userAcepter].iteradorFriendship].sender =
				-1;
		usuariosRegistrados.listaUsuarios[userAcepter].iteradorFriendship--;
		*res = 2;
	}

	return SOAP_OK;
}

int ns__recibir_mensaje(struct soap *soap, struct Usuario user,
		struct Usuario* val) {

	int idUsuario = comprobarNick(user.nickName);

	if (idUsuario == -1) {

		printf("\nusuario no esta online == %d\n", idUsuario);
	} else {

		val->cont_manssage =
				usuariosRegistrados.listaUsuarios[idUsuario].cont_manssage - 1;
		int i;
		for (i = 0; i <= val->cont_manssage; i++) {
			strcpy(val->lista_de_Manssage[i].manssage,
					usuariosRegistrados.listaUsuarios[idUsuario].lista_de_Manssage[i].manssage);

		}

		val = malloc(sizeof(struct Usuario));
	}
	return SOAP_OK;
}

int ns__enviar_mensaje(struct soap *soap, struct Usuario val, int* res) {
	printf("\nNOMBRE DEL SENDER == %s\n", val.lista_de_Manssage[0].sender);
	char reciber[20];
	strcpy(reciber,val.lista_de_Manssage[0].receive);
	char sender[20];
	strcpy(sender,val.lista_de_Manssage[0].sender);

	int id_Receive = comprobarNick(reciber);
	int id_Sender = comprobarNick(sender);

	printf("\nid de id_Receive == %d\n", id_Receive);
	printf("\nid de id_Sender == %d\n", id_Sender);

	if (id_Receive == -1) {
		*res = -1;
		printf("\nusuario no esta online == %d\n", id_Receive);
	} else {
		int j;

		printf(
				"\n (%d)usuariosRegistrados.listaUsuarios[idUsuario].cont_lista_amigos  \n",
				usuariosRegistrados.listaUsuarios[id_Receive].cont_lista_amigos);

		printf(
				"\n (%d)usuariosRegistrados.listaUsuarios[id_Sender].cont_lista_amigos  \n",
				usuariosRegistrados.listaUsuarios[id_Sender].cont_lista_amigos);

		for (j = 0;
				j
						< usuariosRegistrados.listaUsuarios[id_Receive].cont_lista_amigos;
				j++) {

			if (usuariosRegistrados.listaUsuarios[id_Sender].lista_de_amigos[j]
					== id_Receive) {

				int i =
						usuariosRegistrados.listaUsuarios[id_Receive].cont_manssage;
				strcpy(
						usuariosRegistrados.listaUsuarios[id_Receive].lista_de_Manssage[i].manssage,
						val.lista_de_Manssage[val.cont_manssage].manssage);
				usuariosRegistrados.listaUsuarios[id_Receive].cont_manssage++;
				printf("\nTenes total (%d) manssage \n",
						usuariosRegistrados.listaUsuarios[id_Receive].cont_manssage);
			}
		}
		*res = 1;
	}

	return SOAP_OK;
}

void salir(int senal) {

	switch (senal) {
	case SIGINT:
		printf("Cerrando servidor...\n");
	//	guardarListaUsuarios();
		exit(1);
		break;
	}
}
int ns__comprobar_envio(struct soap *soap, struct Usuario val, int* res,
		int* id) {

	return SOAP_OK;
}

int ns__enviar_fichero(struct soap *soap, struct Usuario val, int* res, int* id) {

	return SOAP_OK;
}

int ns__recibir_fichero(struct soap *soap, struct Usuario val, int* res,
		int* id) {

	return SOAP_OK;
}

int cargarListaUsuarios1() {

	int i = 0;
	FILE * fichero = fopen("serverFiles/listaUsuarios/usr.txt", "r");
	if (fichero == NULL) {
		printf("Error al abrir el archivo ListaUsuario, creando uno nuevo.\n");
		fichero = fopen("serverFiles/listaUsuarios", "w\n");
		fclose(fichero);
		return -1;
	} else {
		printf("Cargando listaUsuarios\n");
		fread(&usuariosRegistrados, sizeof(struct ListaUsuarios), 1, fichero);
		while (!feof(fichero)) {
			printf("dentro del bucle\n");
			fread(&usuariosRegistrados, sizeof(struct ListaUsuarios), 1,
					fichero);
		}
		printf("Lista cargada con éxito\n");
		fclose(fichero);
		return 1;
	}

}

int cargarListaUsuarios() {

	int i = 0;
	int fichero = open("listaUsuarios", O_WRONLY | O_CREAT, 0666);
	if (fichero == -1) {
		printf("Error al abrir el archivo ListaUsuario, creando uno nuevo.\n");
		fichero = open("listaUsuarios", O_WRONLY | O_CREAT, 0666);
		close(fichero);
		return -1;
	} else {
		printf("Cargando listaUsuarios\n");
		read(fichero, &usuariosRegistrados, sizeof(struct ListaUsuarios));

		printf("Lista cargada con éxito\n");
		close(fichero);
		return 1;
	}

}
